home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 326-350 / disk_331 / csh / src / comm2.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  13KB  |  604 lines
  1. /*
  2.  * COMM2.C
  3.  *
  4.  * (c)1986 Matthew Dillon     9 October 1986
  5.  *
  6.  * Version 2.07M by Steve Drew 10-Sep-87
  7.  *
  8.  * Version 4.01A by Carlo Borreo & Cesare Dieni 17-Feb-90
  9.  *
  10.  */
  11.  
  12. /* Casting conveniences */
  13. #define BPTR_TO_C(strtag, var)  ((struct strtag *)(BADDR( (ULONG) var)))
  14. #define PROC(task)              ((struct Process *)task)
  15. #define CLI(proc)               (BPTR_TO_C(CommandLineInterface, proc->pr_CLI))
  16.  
  17. /* Externs */
  18. extern int has_wild;                    /* flag set if any arg has a ? or * */
  19.  
  20. /* globals */
  21. int cp_update;
  22. int cp_date;
  23.  
  24. do_abortline()
  25. {
  26. Exec_abortline = 1;
  27. return 0;
  28. }
  29.  
  30. do_return()
  31. {
  32. register int retcode=(ac<2 ? 0 : atoi(av[1]));
  33.    Exec_abortline = 1;
  34.    if (Src_stack) {
  35.        FILE *ptr = (FILE *)Src_base[Src_stack - 1];
  36.        ptr->_bp = ptr->_bend;
  37.        ptr->_flags |= _EOF;
  38. /*     fseek (Src_base[Src_stack - 1], 0L, 2); */
  39.       return retcode;
  40.    } else main_exit(retcode);
  41. }
  42.  
  43. /*
  44.  * STRHEAD
  45.  *
  46.  * place a string into a variable removing everything after and including
  47.  * the 'break' character
  48.  *
  49.  * strhead varname breakchar string
  50.  *
  51.  */
  52.  
  53. do_strhead()
  54. {
  55. char *s;
  56. if (s=index(av[3],*av[2])) *s='\0';
  57. set_var (LEVEL_SET, av[1], av[3]);
  58. return 0;
  59. }
  60.  
  61. do_strtail()
  62. {
  63. char *s;
  64. if (s=index(av[3],*av[2])) s++; else s=av[3];
  65. set_var (LEVEL_SET, av[1], s);
  66. return 0;
  67. }
  68.  
  69. long dptrtosecs(d)
  70. struct DPTR *d;
  71. {
  72. register struct DateStamp *ds=(&d->fib->fib_Date);
  73. return ds->ds_Days*86400 + ds->ds_Minute*60 + ds->ds_Tick/TICKS_PER_SECOND;
  74. }
  75.  
  76. long timeof(s)
  77. char *s;
  78. {
  79. struct DPTR *d;
  80. int dummy;
  81. long n;
  82.  
  83. if ( (d=dopen(s,&dummy))==NULL ) return 0L;
  84. n=dptrtosecs(d);
  85. dclose(d);
  86. return n;
  87. }
  88.  
  89. /*
  90.  * if -f file (exists) or:
  91.  *
  92.  * if A < B   <, >, =, <=, >=, <>, where A and B are either:
  93.  * nothing
  94.  * a string
  95.  * a value (begins w/ number)
  96.  */
  97.  
  98. do_if(garbage, com)
  99. char *garbage;
  100. {
  101. int result;
  102. int i;
  103.  
  104. switch (com) {
  105.     case 0:
  106.     if (If_stack && If_base[If_stack - 1]) If_base[If_stack++] = 1;
  107.     else {
  108.         get_opt("rftmdvn",&i);
  109.         result=evalif(i);
  110.         If_base[If_stack++]=(options & 64 ? result : !result);
  111.         }
  112.     break;
  113.     case 1:
  114.     if (If_stack > 1 && If_base[If_stack - 2]) break;
  115.     if (If_stack) If_base[If_stack - 1] ^= 1;
  116.     break;
  117.     case 2:
  118.     if (If_stack) --If_stack;
  119.     break;
  120.      }
  121. disable = (If_stack) ? If_base[If_stack - 1] : 0;
  122. if (If_stack >= MAXIF) {
  123.     fprintf(stderr,"If's too deep\n");
  124.     disable = If_stack = 0;
  125.     return -1;
  126.     }
  127. if (forward_goto) disable = If_base[If_stack - 1] = 0;
  128. return 0;
  129. }
  130.  
  131. evalif(i)
  132. register unsigned int i;
  133. {
  134. char c;
  135. long num, t0, isint;
  136. long AvailMem();
  137.  
  138. switch(options & ~64) {
  139.     case 0:
  140.     if (ac-i != 3) return (ac>i && *av[i]);
  141.     num  = Atol(av[i]);
  142.     isint  = ! IoErr();
  143.     num -= Atol(av[i+2]);
  144.     isint &= ! IoErr();
  145.     if (!isint) num=strcmp(av[i],av[i+2]);
  146.     if (num < 0)       c='<';
  147.     else if (num > 0)  c='>';
  148.     else if (num == 0) c='=';
  149.     return index(av[i+1], c) != NULL;
  150.     case 1:
  151.     return do_rpn(NULL,i);
  152.     case 2:
  153.     return exists(av[i]);
  154.     case 4:
  155.     t0=timeof(av[i++]);
  156.     for ( ; i<ac ; i++)
  157.         if (t0<=timeof(av[i])) return 1;
  158.     return 0;
  159.     case 8:
  160.     return (AvailMem( (long)MEMF_FAST )!=0);
  161.     case 16:
  162.     return (isdir(av[i])!=0);
  163.     case 32:
  164.     return (get_var(LEVEL_SET,av[i]) != 0);
  165.     default:
  166.     ierror(NULL,500);
  167.     return 0;
  168.     }
  169. }
  170.  
  171. do_label()
  172. {
  173.    char aseek[32];
  174.  
  175.    if (Src_stack == 0) {
  176.       ierror (NULL, 502);
  177.       return (-1);
  178.    }
  179.  
  180.    sprintf (aseek, "%ld %d", Src_pos[Src_stack-1], If_stack);
  181.    set_var (LEVEL_LABEL + Src_stack - 1, av[1], aseek);
  182.    if (!strcmp(av[1],get_var(LEVEL_SET,v_gotofwd)))
  183.       forward_goto = 0;
  184.    return 0;
  185. }
  186.  
  187. do_goto()
  188. {
  189.    int new;
  190.    long pos;
  191.    char *lab;
  192.  
  193.    if (Src_stack == 0) {
  194.       ierror (NULL, 502);
  195.    } else {
  196.       lab = get_var (LEVEL_LABEL + Src_stack - 1, av[1]);
  197.       if (lab == NULL) {
  198.          forward_goto = 1;
  199.          set_var (LEVEL_SET, v_gotofwd, av[1]);
  200.          return(0);
  201.       } else {
  202.          pos = atoi(lab);
  203.          fseek (Src_base[Src_stack - 1], pos, 0);
  204.          Src_pos[Src_stack - 1] = pos;
  205.          new = atoi(next_word(lab));
  206.          for (; If_stack < new; ++If_stack)
  207.             If_base[If_stack] = 0;
  208.          If_stack = new;
  209.       }
  210.    }
  211.    Exec_abortline = 1;
  212.    return (0);      /* Don't execute rest of this line */
  213. }
  214.  
  215.  
  216. do_inc(garbage, com)
  217. char *garbage;
  218. {
  219. char *var, num[32];
  220.  
  221. if (ac>2) com *= atoi(av[2]);
  222. if (var = get_var (LEVEL_SET, av[1])) {
  223.     sprintf (num, "%d", atoi(var)+com);
  224.     set_var (LEVEL_SET, av[1], num);
  225.     }
  226. return 0;
  227. }
  228.  
  229. do_input()
  230. {
  231. char in[256], *p,*s;
  232. unsigned int i;
  233.  
  234. for (i=1; i < ac; ++i)
  235.     if (gets(in)) {
  236.     for(p = in; *p; p = s) {
  237.         s = next_word(p);
  238.         if (*s) *(s-1) = 0xA0;
  239.         }
  240.     set_var (LEVEL_SET, av[i], in);
  241.     }
  242. return 0;
  243. }
  244.  
  245. do_ver()
  246. {
  247. extern char shellname[];
  248.  
  249. puts(shellname);
  250. puts("(c)1986 Matthew Dillon\n\
  251. Manx (M) versions by Steve Drew\n\
  252. ARP (A) versions by Carlo Borreo & Cesare Dieni\n");
  253. return 0;
  254. }
  255.  
  256. do_ps()
  257. {
  258. /* this code fragment based on ps.c command by Dewi Williams */
  259.  
  260. register int    count;        /* loop variable        */
  261. struct Task    *task;        /* EXEC descriptor        */
  262. char        strbuf[64+1];    /* scratch for btocstr()    */
  263. char        cmd[40+1];    /* holds cmd name        */
  264. long ncli;
  265.  
  266. printf("Proc Command Name         CLI Type    Pri.  Address  Directory\n");
  267. Forbid();
  268.  
  269. ncli=(long)FindCLI(0L);
  270. for (count = 1; count <= ncli ; count++)
  271.         /* or just assume 20?*/
  272.     if (task = (struct Task *)FindCLI((long)count)) {
  273.     if (task==NULL) continue;
  274.     /* Sanity check just in case */
  275.     if (PROC(task)->pr_TaskNum == 0 || PROC(task)->pr_CLI == 0) continue;
  276.                             /* or complain? */
  277.     BtoCStr(cmd,   CLI(PROC(task))->cli_CommandName, 40L);
  278.     BtoCStr(strbuf,CLI(PROC(task))->cli_SetName    , 64L);
  279.     printf("%2d   %-20.20s %-11.11s %3d  %8lx  %s\n",
  280.         count,
  281.         cmd,
  282.         task->tc_Node.ln_Name,
  283.         task->tc_Node.ln_Pri,
  284.         task,
  285.         strbuf);
  286.     }
  287. Permit();
  288. return 0;
  289. }
  290.  
  291. /*
  292.  * CP [-d] [-u] file file
  293.  * CP [-d] [-u] file file file... destdir
  294.  * CP [-r][-u][-d] dir dir dir... destdir
  295.  */
  296.  
  297. char *errstr;          /* let's be alittle more informative */
  298.  
  299. do_copy()
  300. {
  301. register int recur, ierr;
  302. register char *destname;
  303. register char destisdir;
  304. register FIB *fib;
  305. int i;
  306.  
  307. errstr = "";
  308. ierr = 0;
  309.  
  310. fib = (FIB *)AllocMem((long)sizeof(FIB), MEMF_PUBLIC);
  311.  
  312. get_opt("rud",&i);
  313. recur     = (options & 0x01);
  314. cp_update = (options & 0x02);
  315. cp_date   = (!(options & 0x04)); /* the default is keep orignal file date */
  316.  
  317. destname = av[ac - 1];
  318.  
  319. if (ac < i + 2) {
  320.     ierr = 500;
  321.     goto done;
  322.     }
  323. destisdir = isdir(destname);
  324. if (ac > i + 2 && !destisdir) {
  325.     ierr = 507;
  326.     goto done;
  327.     }
  328.  
  329. /*
  330.  * copy set:                        reduce to:
  331.  *    file to file                     file to file
  332.  *    dir  to file (NOT ALLOWED)
  333.  *    file to dir                      dir to dir
  334.  *    dir  to dir                      dir to dir
  335.  *
  336.  */
  337.  
  338. for (; i<ac-1 && !dobreak(); ++i) {
  339.     short srcisdir = isdir(av[i]);
  340.     if (srcisdir && has_wild && (ac >2)) /* hack to stop dir's from */
  341.         continue;             /* getting copied if specified */
  342.                          /* from wild expansion */
  343.     if (srcisdir) {
  344.         BPTR srcdir, destdir;
  345.         if (!destisdir) {
  346.             if (exists(destname)) {
  347.                 ierr = 507;    /* disallow dir to file */
  348.                 goto done;
  349.                 }
  350.             if (destdir = CreateDir(destname)) UnLock(destdir);
  351.             destisdir = 1;
  352.             }
  353.         if (!(destdir = Lock(destname, ACCESS_READ))) {
  354.             ierr = 205;
  355.             errstr = destname;
  356.             goto done;
  357.             }
  358.         if (!(srcdir = Lock(av[i], ACCESS_READ))) {
  359.             ierr = 205;
  360.             errstr = av[i];
  361.             UnLock(destdir);
  362.             goto done;
  363.             }
  364.         ierr = copydir(srcdir, destdir, recur);
  365.         UnLock(srcdir);
  366.         UnLock(destdir);
  367.         if (ierr) break;
  368.         }
  369.     else {        /* FILE to DIR,   FILE to FILE   */
  370.         BPTR destdir, srcdir, tmp;
  371.         char *destfilename;
  372.  
  373.         srcdir = (BPTR)(Myprocess->pr_CurrentDir);
  374.  
  375.         if ((tmp = Lock(av[i], ACCESS_READ)) == NULL || !Examine(tmp,fib)) {
  376.             if (tmp) UnLock(tmp);
  377.             ierr = 205;
  378.             errstr = av[i];
  379.             goto done;
  380.             }
  381.         UnLock(tmp);
  382.         if (destisdir) {
  383.             destdir = Lock(destname, ACCESS_READ);
  384.             destfilename = fib->fib_FileName;
  385.             }
  386.         else {
  387.             destdir = srcdir;
  388.             destfilename = destname;
  389.             }
  390.         printf(" %s..",av[i]);
  391.         fflush(stdout);
  392.         ierr = copyfile(av[i], srcdir, destfilename, destdir);
  393.         if (destisdir) UnLock(destdir);
  394.         if (ierr) break;
  395.         }
  396.     }
  397.  
  398. done:
  399.  
  400. FreeMem(fib, (long)sizeof(FIB));
  401. if (ierr) {
  402.     ierror(errstr, ierr);
  403.     return(20);
  404.     }
  405. return 0;
  406. }
  407.  
  408.  
  409. copydir(srcdir, destdir, recur)
  410. register BPTR srcdir, destdir;
  411. {
  412.    BPTR cwd;
  413.    register FIB *srcfib;
  414.    register BPTR destlock, srclock;
  415.    int ierr;
  416.    static int level;
  417.  
  418.    level++;
  419.    ierr = 0;
  420.    srcfib = (FIB *)AllocMem((long)sizeof(FIB), MEMF_PUBLIC);
  421.    if (Examine(srcdir, srcfib)) {
  422.       while (ExNext(srcdir, srcfib)) {
  423.          if (CHECKBREAK())
  424.             break;
  425.          if (srcfib->fib_DirEntryType < 0) {
  426.             printf("%*s%s..",(level-1) * 6," ",srcfib->fib_FileName);
  427.             fflush(stdout);
  428.             ierr = copyfile(srcfib->fib_FileName,srcdir,srcfib->fib_FileName,destdir);
  429.             if (ierr)
  430.                break;
  431.          } else {
  432.             if (recur) {
  433.                cwd = CurrentDir(srcdir);
  434.                if (srclock = Lock(srcfib->fib_FileName, ACCESS_READ)) {
  435.                   CurrentDir(destdir);
  436.                   if (!(destlock = Lock(srcfib->fib_FileName, ACCESS_WRITE))) {
  437.                      destlock = CreateDir(srcfib->fib_FileName);
  438.                      printf("%*s%s (Dir)....[Created]\n",(level-1) * 6,
  439.                                 " ",srcfib->fib_FileName);
  440.  
  441.                         /* UnLock and re Lock if newly created
  442.                            for file_date() to work properly
  443.                         */
  444.                      if (destlock) UnLock(destlock);
  445.                      destlock = Lock(srcfib->fib_FileName, ACCESS_WRITE);
  446.                   }
  447.                   else
  448.                      printf("%*s%s (Dir)\n",(level-1) * 6," ",srcfib->fib_FileName);
  449.                   if (destlock) {
  450.                      ierr = copydir(srclock, destlock, recur);
  451.                      UnLock(destlock);
  452.                   } else {
  453.                      ierr = (int)((long)IoErr());
  454.                   }
  455.                   UnLock(srclock);
  456.                } else {
  457.                   ierr = (int)((long)IoErr());
  458.                }
  459.                CurrentDir(cwd);
  460.                if (ierr)
  461.                   break;
  462.             }
  463.          }
  464.       }
  465.    } else {
  466.       ierr = (int)((long)IoErr());
  467.    }
  468.    --level;
  469.    FreeMem(srcfib, (long)sizeof(FIB));
  470.    return(ierr);
  471. }
  472.  
  473.  
  474. copyfile(srcname, srcdir, destname, destdir)
  475. char *srcname, *destname;
  476. BPTR srcdir, destdir;
  477. {
  478. BPTR cwd;
  479. BPTR f1, f2;
  480. long i;
  481. int stat,ierr;
  482. char *buf;
  483. struct DPTR *dp, *dps = NULL;
  484.  
  485. if ((buf = (char *)AllocMem(8192L, MEMF_PUBLIC|MEMF_CLEAR))==NULL)
  486.     { ierr = 103; goto fail; }
  487. ierr = 0;
  488. cwd = CurrentDir(srcdir);
  489. if ((f1=Open(srcname, MODE_OLDFILE))==NULL)
  490.     { errstr = srcname; ierr = 205; goto fail; }
  491. dps = dopen(srcname,&stat);
  492. CurrentDir(destdir);
  493. if (cp_update)
  494.     {
  495.     dp=dopen(destname, &stat);
  496.     if ( dptrtosecs(dp) >= dptrtosecs(dps) &&
  497.         !strcmp(dps->fib->fib_FileName, dp->fib->fib_FileName))
  498.         { dclose(dp); Close(f1); printf("..not newer\n"); goto fail; }
  499.     dclose(dp);
  500.     }
  501. if ((f2=Open(destname, MODE_NEWFILE))==NULL)
  502.     { Close(f1); ierr = (int)((long)IoErr()); errstr=destname; goto fail;  }
  503. while (i = Read(f1, buf, 8192L))
  504.     if (Write(f2, buf, i) != i) { ierr = (int)((long)IoErr()); break; }
  505. Close(f2);
  506. Close(f1);
  507. if (!ierr)
  508.     {
  509.     if (cp_date) file_date(&dps->fib->fib_Date, destname);
  510.     printf("..copied\n");
  511.     }
  512. else DeleteFile(destname);
  513. fail:
  514.  dclose(dps);
  515.  if (buf) FreeMem(buf, 8192L);
  516.  CurrentDir(cwd);
  517.  return(ierr);
  518. }
  519.  
  520. do_touch()
  521. {
  522. struct DateStamp ds;
  523. register unsigned int i;
  524. DateStamp(&ds);
  525. for (i=1; i<ac; i++) if (file_date(&ds, av[i])) ierror(av[i],500);
  526. return 0;
  527. }
  528.  
  529. file_date(date,name)
  530. struct DateStamp *date;
  531. char *name;
  532. {
  533. long packargs[7];
  534. UBYTE *ptr;
  535. struct MsgPort *task;
  536. BPTR dirlock;
  537. struct DPTR *tmp;
  538. int stat;
  539.  
  540. if (!(task = (struct MsgPort *)DeviceProc(name))) return(1);
  541. if (tmp = dopen(name, &stat)) {
  542.     dirlock = ParentDir(tmp->lock);
  543.     ptr=AllocMem(65L,MEMF_PUBLIC);
  544.     CtoBStr(tmp->fib->fib_FileName,(ULONG)ptr >> 2L,64L);
  545.     dclose(tmp);
  546.     packargs[1]=dirlock;
  547.     packargs[2]=(ULONG)ptr >> 2L;
  548.     packargs[3]=(long)date;
  549.     SendPacket(ACTION_SET_DATE,packargs,task);
  550.     UnLock(dirlock);
  551.     FreeMem(ptr,65L);
  552.     }
  553. return 0;
  554. }
  555.  
  556. do_addbuffers()
  557. {
  558. long packargs[7];
  559. long n;
  560. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  561.  
  562. if (!task) { ierror(av[1],510); return 20; }
  563. n=myatoi(av[2],1,32767); if (atoierr) return 20;
  564. packargs[0]=n;
  565. SendPacket(ACTION_MORE_CACHE,packargs,task);
  566. return 0;
  567. }
  568.  
  569. do_relabel()
  570. {
  571. long packargs[7];
  572. UBYTE *ptr;
  573. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  574.  
  575. if (!task) { ierror(av[1],510); return 20; }
  576. ptr=AllocMem(65L,MEMF_PUBLIC);
  577. CtoBStr(av[2],(ULONG)ptr >> 2L,64L);
  578. packargs[0]=(ULONG)ptr >> 2L;
  579. SendPacket(ACTION_RENAME_DISK,packargs,task);
  580. FreeMem(ptr,65L);
  581. changedisk(task);
  582. return 0;
  583. }
  584.  
  585. do_diskchange()
  586. {
  587. struct MsgPort *task=(struct MsgPort *)DeviceProc(av[1]);
  588.  
  589. if (!task) { ierror(av[1],510); return 20; }
  590. changedisk(task);
  591. return 0;
  592. }
  593.  
  594. changedisk(task)
  595. struct MsgPort *task;
  596. {
  597. long packargs[7];
  598.  
  599. packargs[0]=1L;
  600. SendPacket(ACTION_INHIBIT,packargs,task);
  601. packargs[0]=0L;
  602. SendPacket(ACTION_INHIBIT,packargs,task);
  603. }
  604.